A Java programozási nyelv alapjai
Változók lehetséges típusai

Típus Érték
boolean (logikai, igaz vagy hamis) true, false
int (egész szám) 10,  24
double (valós szám) 10.5
char (karakter) 'c'
String (szöveges) "szoveg"
stb...  


Változók, tömbök deklarálása
A változók deklarálása a változó típusának és nevének megadásából áll. Deklaráció esetén lehetséges értékadás is. A a deklarációkkal azonban vigyáznunk kell, ha egy metódusban tesszük azt meg, akkor az a változó csak az adott metóduson belül érhető el.
Példa deklarációra:
   int i;   -    egyész típusú, i nevű változó deklarálása
   boolean f=true;   -    boolean típusú, f nevű, true értékkel rendelkező változó deklarálása

Tömbök deklarálása
A tömbök olyan homogén adatszerkezetek, amelyek meghatározott számú elemet tartalmazhatnak. A homogén tulajdonság azt jelenti, hogy csak azonos típusú elemeket adhatunk meg tömbelemeknek.
Példa deklarációra:
   int[] tomb=new int[10]    -    így létrehoztunk egy 10 elemű, tomb nevű, egész típusú tömböt
A tömb elemeinek így adhatunk értéket:
   tomb[0]=20;   -   Java-ban a tömb elemeinek indexe nullával kezdődik, így egy 10 elemű tömb esetében az utolsó tömbindex a 9.


Változók értékének növelése és csökkentése
Változók értékének változtatását többféle képpen is megadhatjuk, ha eggyel kívánjuk növelni vagy csökkenteni, akkor azt így tehetjük meg:
     valtozo=valtozo+1;   vagy   valtozo=valtozo-1;
Ezzel egyenértékű a valtozo++; utasítás, csökkentéskor a valtozo--; utasítást használjuk.
Az értékmódosítás egy módja a ++valtozo; vagy --valtozo; utasítás is.
Az, hogy melyik utasítást hazsnáljuk attól függ, hogy  utólag vagy előbb szeretnénk növelni a változó értékét. Ha az utóbbiról van szó akkor a ++valtozo; vagy --valtozo; utasításokat alkalmazzuk, ha az előbbiről, akkor pedig a valtozo++; vagy valtozo--; utasításokat.

Ha nem eggyel, hanem meghatározott értékkel szeretnénk módosítani a változó értékét, akkor azt a következő módokon tehetjük meg:
        valtozo=valtozo+5;   vagy   valtozo=valtozo-5;
Vagy az előbb ismertetett megoldás elvével:
        valtozo+=5;   vagy   valtozo-=5;


Feltételes utasítások megadásakor használható műveleti jelek és jelentésük

 ==    Egyenlőség vizsgálata. (Az egyszerű egyenlőségjel értékadást jelent.)
!=    Az egyenlőség tagadása, azaz nem egyenlő
 <     A bal oldalon lévő érték kisebb, mint a jobboldali
 >     A bal oldalon lévő érték nagyobb, mint a jobboldali
 <=    A bal oldalon lévő érték kisebb vagy egyenlő, mint a jobboldali, tehát már megengedett az egyenlőség is
 >=    A bal oldalon lévő érték nagyobb vagy egyenlő, mint a jobboldali, már megengedett az egyenlőség is


Feltételes utasítások logikai operátorokkal egészíthetőek ki, vagy kapcsolhatóak össze.
Logikai operátorok:

 &&   Az ÉS operátor jele.
      Pl.: ((i>4) && (i<=20))  -  Ez a feltétel csak akkor teljesül, ha az i nagyobb, mint 4 ÉS kisebb vagy egyenlő 20-nál.
 ||   A VAGY operátor jele.
      Pl.: ((x<10) || (x==1))  -  Ez a feltétel VAGY akkor teljesül, ha az x kisebb, mint 10, VAGY ha az x egyenlő eggyel.
 !    A NEM operátor jele.
       Pl.:  !(b<20)   -   Ez a feltétel akkor teljesül, ha a b NEM kisebb, mint 20.


Vezérlési szerkezetek
  • Ciklusok
    • for iklus
    • while ciklus
    • do - while ciklus
    • Kilépés a ciklusból (break)
  • Elágazások
    • Egyirányú elágazások
    • Kétirányú elágazások
    • Többirányú elágazások

Ciklusok

A for ciklus
Rögzített lépésszámú ciklus. Akkor hazsnáljuk, ha tudjuk, hogy a ciklus hányszor fog lefutni.
A for ciklus felépítése:
      for (előkészítő_rész; ltételes_rész; növekményes_rész;){
         ciklusmag
         }  

Az előkészítő részben adjuk meg a ciklusváltozó kezdőértékét. A feltételes részben vizsgáljuk azt, hogy a ciklusváltozó csökkentett vagy növelt értéke elérte-e már a kívánt értéket. A növekményes részben változtatjuk (növeljük vagy csökkentjük) a változó értékét.


A while ciklus
A while ciklus előltesztelő ciklus, tehát ha a ciklusfeltétel nem teljesül, a ciklusmag nem fut le. Így előforulhat az is, hogy a ciklus egyszer sem fut le.
A while ciklus felépítése:

      while (ciklusfeltétel){
         ciklusmag
         }  

A ciklus addig fut, amíg a ciklusfeltétel teljesül. (A lehetséges ciklusfeltételeket, azaz logikai kifejezéseket fentebb részleteztük.)

A do - while ciklus
A do - while ciklus hátultesztelő ciklus, tehát attól függetlenül, hogy a ciklusfeltétel teljesül-e vagy sem, a ciklusmag mindenképpen lefut egyszer.
A do - while ciklus felépítése:

      do{
         ciklusmag
         }while(ciklusfeltétel);  

A ciklus addig fur, amíg a ciklusfeltétel teljesül.

Kilépés a ciklusból (break)
A ciklusból történő kilépés a break; utasítással történik. Ennek köszönhetően a ciklusból "kiugrunk" és az utána következő utasítással folytatódik a program futása.


Elágazások

Egyirányú elágazások (if)
Az egyirányú elágazások felépítése:

      if(logikai_kifejezés){
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         }  

Az if feltételes utasításban szereplő utasítások csak akkor futnak le, ha a logikai kifejezés teljesül. A kapcsos zárójelek közötti részt utasításblokknak nevezzük, és a benne szereplő utasítások egy utasításnak felelnek meg. A logikai kifejezés megadása után, ha csak egy utasítás áll, a kapcsos zárójelek elhagyhatóak.

Kétirányú elágazások (if - else)
A kétirányú elágazások felépítése:

      if(logikai_kifejezés){
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         }
      else{
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         } 

Ha a logikai kifejezések után csak egy utasítás szerepel, a kapcsoszárójelek elhagyhatóak. A feltételes utasítások egymásba is ágyazhatóak.
Az egymásba ágyazott kétirányú elágazások felépítése:

      if(logikai_kifejezés){
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         }
      else if(logikai_kifejezés){
         utasítás_1;
         utasítás_2;
         ...
         utasítás_n;
         }
         else{
            utasítás_1;
            utasítás_2;
            ...
            utasítás_n;
            } 

A feltételes utasítások bármilyen mélységben egymásba ágyazthatóak.

Többirányú elágazások (switch - case)
A többirányú elágazásokat akkor hazsnáljuk, amikor egy változó többféle értéket vehet fel, és a különböző esetekben más és más utasítás hajtódjon végre.
A többirányú elágazások felépítése:

      switch(változó){
         case érték_1: utasítás_1; break;
         case érték_2: utasítás_2; break;
         ...
         default: utasítás_n;
         }  

A case-ek után adjuk meg a változó által felvehető lehetséges értéket majd kettősponttal elválasztva a végrehajtandó utasítást. Ezután egy break; utasítás következik, melynek köszönhetően átugunk a switch - case között lévő további utasításokon. A break utasítás elhagyható, de a programunk futását gyorsítja, hiszen felesleges a többi lehetőséget vizsgálni, ha már az egyiknél egyezést találtunk. A többirányú elágazás esetén van egy olyan speciális lehetőségünk, amely minden egyéb nem megadott lehetőség esetén következik be, ezt a default: utasítás; paranccsal tehetjük meg.

Példát csak erre az elágazástípusra mutatunk be, mivel ez talán a legbonyolultabb, illetve a további programokban sem fog szerepelni ennek alkalmazása.
Erre példaként egy olyan programot írunk, amely billentyűzetről bekér egy érdemjegyet, és azt kiírja szövegesen.
A hozzá tartozó folyamatábra a következő:



import java.io.*;
public class Jegyek{
   public static int in() throws Exception{
      LineNumberReader x=new LineNumberReader(new InputStreamReader(System.in));
      String s=x.readLine();
      int i=Integer.parseInt(s);
      return i;
      }
   public static void main(String[] args) throws Exception{
      int n;
      System.out.print("Érdemjegy: ");
      n=in();
      switch(n){
         case 1: System.out.println("Elégtelen"); break;
         case 2: System.out.println("Elégséges"); break;
         case 3: System.out.println("Közepes"); break;
         case 4: System.out.println("Jó"); break;
         case 5: System.out.println("Jeles"); break;
         default: System.out.println("???");
         }
      }
   }


Metódusok
  • Eljárások
  • Függvények
Az metódusoknak két típusa van: statikus (osztályszintű), vagy nem statikus metódusok. A "Programozás alapjai" c. kurzus során mi csak a statikus metódusokat alkalmazzuk.

Eljárások
A statikus eljárások felépítése:

      public static void eljárás_neve(formális_paraméterlista){
         eljárás_törzsrésze
         }

A public szó az eljárás láthatóságát, hozzáférhetőségét biztosítja más programok számára.
A static jelenti azt, hogy az eljárás statikus azaz osztályszintű. Ez biztosítja számunkra, hogy minden metódusban (függetlenül attól hogy statikus-e vagy sem) példányosítás nélkül legyen elérhető. A példányosításról ebben  afélévebn nem esik szó, mivel minden egyes metódust statikusnak definiálunk.
A void jelzi, hogy nem lesz a metódusnak visszatérési értéke, tehát eljárásról van szó.
Az eljárás neve után mindig szerepel a dupla kerek zárójel (), mely között a formális paraméterlista helyezkedik el. A formális paraméterlista a bemenő paraméterek nevét és típusát tartalmazza. Egy eljárásnak nem feltétlenül van bemenő paramétere, azok száma lehet 0, 1 vagy több is. Ha többet is megadunk, azokat vesszővel választjuk el egymástól.

Függvények
A függvényt a visszatérési érték különbözteti meg az eljárástól.
A statikus függvények felépítése:

     public static visszatérési_érték_típusa függvény_neve(formális_paramlista){
         függvény_törzsrésze
         return visszatérési_érték;
         }  

A visszatérési érték típusát a függvény nevének megadása előtt kell megadnunk, ez lehet egésztípus, logikai, azaz boolean típus, String típus, satöbbi. A formális paraméterlista megadására ugyanaz vonatkozik, mint az eljárások esetében.
A visszatérési értéket a return visszatérési_érték; utasítás adja vissza. Return-t mindig tartalmaznia kell egy függvénynek, és nem szabad olyan feltételes utasításba helyeznünk, ami lehetséges, hogy nem teljesül, és így  return utasítás nem kerül végrehajtásra.

A metódusok a Java programok main metódusában kerülnek meghívásra. A bemenő paraméterek ekkor kapnak értéket. Mikor megadjuk egy metódus meghívásakor a paramétereket, azt aktuális paraméterlistának nevezzük.